package $4reflection;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


public class $4_1_FnClass {

    static final Logger logger = LoggerFactory.getLogger($4_1_FnClass.class);
    
    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        /**
         * 反射（Reflection）
         * 
         * Class类
         * 除了int等基本类型外，Java的其他类型全部都是class（包括interface）。
         * 例如：String、Object、Runnable、Exception
         * class（包括interface）的本质是数据类型（Type）。无继承关系的数据类型无法赋值。
         * 而class是由JVM在执行过程中动态加载的。
         * JVM在第一次读取到一种class类型时，将其加载进内存。
         * 每加载一种class，JVM就为其创建一个Class类型的实例，并关联起来。
         * 所以，JVM持有的每个Class实例都指向一个数据类型（class或interface）
         * 一个Class实例包含了该class的所有完整信息
         * 由于JVM为每个加载的class创建了对应的Class实例，并在实例中保存了该class的所有信息，
         * 包括类名、包名、父类、实现的接口、所有方法、字段等，因此，如果获取了某个Class实例，
         * 我们就可以通过这个Class实例获取到该实例对应的class的所有信息。
         * 这种通过Class实例获取class信息的方法称为反射（Reflection）。
         * 
         * 获取一个class有三个方法：
         * 1、直接通过一个class的静态变量class获取
         * 2、如果我们有一个实例变量，可以通过该实例变量提供的getClass()方法获取
         * 3、如果知道一个class的完整类名，可以通过静态方法Class.forName()获取
         * 因为Class实例在JVM中是唯一的，所以，上述方法获取的Class实例是同一个实例。可以用==比较两个Class实例
         * 
         * 小结
         * JVM为每个加载的class及interface创建了对应的Class实例来保存class及interface的所有信息；
         * 获取一个class对应的Class实例后，就可以获取该class的所有信息；
         * 通过Class实例获取class信息的方法称为反射（Reflection）；
         * JVM总是动态加载class，可以在运行期根据条件来控制加载class。
         */
        
        // 方法一：直接通过一个class的静态变量class获取：
        Class cls1 = String.class;
        // 方法二：如果我们有一个实例变量，可以通过该实例变量提供的getClass()方法获取：
        String s = "Hello";
        Class cls2 = s.getClass();
        // 方法三：如果知道一个class的完整类名，可以通过静态方法Class.forName()获取：
        Class cls3 = Class.forName("java.lang.String");
        // 因为Class实例在JVM中是唯一的，所以，上述方法获取的Class实例是同一个实例。可以用==比较两个Class实例：
        boolean sameClass = cls1 == cls2; // true
        logger.info("sameClass {}", sameClass);
        
        // 注意一下Class实例比较和instanceof的差别
        Integer n = new Integer(123);

        boolean b1 = n instanceof Integer; // true，因为n是Integer类型
        boolean b2 = n instanceof Number;  // true，因为n是Number类型的子类

        logger.info("n.getClass().equals(Integer.class) :{}",n.getClass().equals(Integer.class)); // true，因为n.getClass()返回Integer.class
        logger.info("n.getClass().equals(Number .class) :{}",n.getClass().equals(Number.class));  // false，因为Integer.class!=Number.class
        
        // 用instanceof不但匹配指定类型，还匹配指定类型的子类。而用==判断class实例可以精确地判断数据类型，但不能作子类型比较。
        // 通常情况下，我们应该用instanceof判断数据类型，因为面向抽象编程的时候，我们不关心具体的子类型。
        // 只有在需要精确判断一个类型是不是某个class的时候，我们才使用==判断class实例。
        // 因为反射的目的是为了获得某个实例的信息。因此，当我们拿到某个Object实例时，我们可以通过反射获取该Object的class信息
        
        printClassInfo("".getClass());
        printClassInfo(Runnable.class);
        printClassInfo(java.time.Month.class);
        printClassInfo(String[].class);
        printClassInfo(int.class);
        
        // 注意到数组（例如String[]）也是一种Class，而且不同于String.class，它的类名是[Ljava.lang.String。
        // 此外，JVM为每一种基本类型如int也创建了Class，通过int.class访问。
        
        // 如果获取到了一个Class实例，我们就可以通过该Class实例来创建对应类型的实例：
     // 获取String的Class实例:
        Class cls = String.class;
        // 创建一个String实例:
        String s2 = (String) cls.newInstance();
        // 上述代码相当于new String()。
        // 通过Class.newInstance()可以创建类实例，它的局限是：只能调用public的无参数构造方法。
        // 带参数的构造方法，或者非public的构造方法都无法通过Class.newInstance()被调用。
        
        // 动态加载
        // JVM在执行Java程序的时候，并不是一次性把所有用到的class全部加载到内存，而是第一次需要用到class时才加载。
        // 利用JVM动态加载class的特性，我们才能在运行期根据条件加载不同的实现类。
        // 例如，Commons Logging总是优先使用Log4j，只有当Log4j不存在时，才使用JDK的logging。
        // 
        
    }
    
    static void printClassInfo(Class cls) {
        logger.info("Class name: " + cls.getName());
        logger.info("Simple name: " + cls.getSimpleName());
        if (cls.getPackage() != null) {
            logger.info("Package name: " + cls.getPackage().getName());
        }
        logger.info("is interface: " + cls.isInterface());
        logger.info("is enum: " + cls.isEnum());
        logger.info("is array: " + cls.isArray());
        logger.info("is primitive: " + cls.isPrimitive());
    }
}
